﻿// ECMAScript 5 strict mode
"use strict";

assert2(cr, "cr namespace not created");
assert2(cr.plugins_, "cr.plugins_ not created");

/////////////////////////////////////
// Plugin class
cr.plugins_.Gamedu = function(runtime)
{
	this.runtime = runtime;
};

(function ()
{
	var pluginProto = cr.plugins_.Gamedu.prototype;
		
	/////////////////////////////////////
	// Object type class
	pluginProto.Type = function(plugin)
	{
		this.plugin = plugin;
		this.runtime = plugin.runtime;
	};

	var typeProto = pluginProto.Type.prototype;

	// called on startup for each object type
	typeProto.onCreate = function()
	{
	};
	
	var gameduRuntime = null;
	var gameduInst = null;
	var gameduapi = null;

	var getGameDataResponse='';
	var defaultPlayerData = '';
	var defaultGameData = '';
	
	var gameduBlocklyhasBlocks = 0;
	var gameduBlocklyCurrUID = 0;
	var gameduBlocklyMovement = '';
	
	
	var getGameDataCallback = function(result)
	{
		// Save the returned data
		getGameDataResponse = result;
		if (getGameDataResponse == null) getGameDataResponse = "";

		// Activate related trigger
		gameduRuntime.trigger(cr.plugins_.Gamedu.prototype.cnds.gameduOnGetGameData, gameduInst);
	}

	/////////////////////////////////////
	// Instance class
	pluginProto.Instance = function(type)
	{
		this.type = type;
		this.runtime = type.runtime;
		
		// any other properties you need, e.g...
		// this.myValue = 0;
	};
	
	var instanceProto = pluginProto.Instance.prototype;

	// called whenever an instance is created
	instanceProto.onCreate = function()
	{
		// note the object is sealed after this call; ensure any properties you'll ever need are set on the object
		// e.g...
		// this.myValue = 0;
		
		gameduRuntime = this.runtime;
		gameduInst = this;

		gameduapi = {
			parentFunc: function(funcName, params) {
				try {
					console.log("testa params");
					return window["gamedugame"][funcName](params);
				}
				catch (e) {
					console.log("sem params");
					return window["gamedugame"][funcName]();
				}
				
				
				
			}
		}
		
		//tell gamedu that we are alive, and get sessionTime and default playerData
		var result = gameduapi.parentFunc('startGame');
	};
	
	// called whenever an instance is destroyed
	// note the runtime may keep the object after this call for recycling; be sure
	// to release/recycle/reset any references to other objects in this function.
	instanceProto.onDestroy = function ()
	{
	};
	
	// called when saving the full state of the game
	instanceProto.saveToJSON = function ()
	{
		// return a Javascript object containing information about your object's state
		// note you MUST use double-quote syntax (e.g. "property": value) to prevent
		// Closure Compiler renaming and breaking the save format
		return {
			// e.g.
			//"myValue": this.myValue
		};
	};
	
	// called when loading the full state of the game
	instanceProto.loadFromJSON = function (o)
	{
		// load from the state previously saved by saveToJSON
		// 'o' provides the same object that you saved, e.g.
		// this.myValue = o["myValue"];
		// note you MUST use double-quote syntax (e.g. o["property"]) to prevent
		// Closure Compiler renaming and breaking the save format
	};
	
	// only called if a layout object - draw to a canvas 2D context
	instanceProto.draw = function(ctx)
	{
	};
	
	// only called if a layout object in WebGL mode - draw to the WebGL context
	// 'glw' is not a WebGL context, it's a wrapper - you can find its methods in GLWrap.js in the install
	// directory or just copy what other plugins do.
	instanceProto.drawGL = function (glw)
	{
	};
	
	// The comments around these functions ensure they are removed when exporting, since the
	// debugger code is no longer relevant after publishing.
	/**BEGIN-PREVIEWONLY**/
	instanceProto.getDebuggerValues = function (propsections)
	{
		// Append to propsections any debugger sections you want to appear.
		// Each section is an object with two members: "title" and "properties".
		// "properties" is an array of individual debugger properties to display
		// with their name and value, and some other optional settings.
		propsections.push({
			"title": "My debugger section",
			"properties": [
				// Each property entry can use the following values:
				// "name" (required): name of the property (must be unique within this section)
				// "value" (required): a boolean, number or string for the value
				// "html" (optional, default false): set to true to interpret the name and value
				//									 as HTML strings rather than simple plain text
				// "readonly" (optional, default false): set to true to disable editing the property
				
				// Example:
				// {"name": "My property", "value": this.myValue}
			]
		});
	};
	
	instanceProto.onDebugValueEdited = function (header, name, value)
	{
		// Called when a non-readonly property has been edited in the debugger. Usually you only
		// will need 'name' (the property name) and 'value', but you can also use 'header' (the
		// header title for the section) to distinguish properties with the same name.
		if (name === "My property")
			this.myProperty = value;
	};
	/**END-PREVIEWONLY**/

	//////////////////////////////////////
	// Conditions
	function Cnds() {};

	// the example condition
	Cnds.prototype.MyCondition = function (myparam)
	{
		// return true if number is positive
		return myparam >= 0;
	};
	
	// ... other conditions here ...
	
	pluginProto.cnds = new Cnds();
	
	//////////////////////////////////////
	// Actions
	function Acts() {};

	// the example action
	Acts.prototype.MyAction = function (myparam)
	{
		// alert the message
		alert(myparam);
	};
	
	Acts.prototype.gameduGetGameData = function()
	{
		defaultGameData = gameduapi.parentFunc('startGame',[]);
		//console.log(defaultGameData["player"]);
		defaultPlayerData = defaultGameData["player"];
		//console.log(defaultPlayerData["name"]);
	};
	
	Acts.prototype.gameduSetGameStats = function(victory_, tries_, time_)
	{
		console.log("Venceu: "+victory_);
		console.log("Tentativas: "+tries_);
		console.log("Tempo: "+time_);
		gameduapi.parentFunc('setGameStats', [victory_, tries_, time_]);
	};
	
	Acts.prototype.gameduHasBlocks = function()
	{
		gameduBlocklyhasBlocks = gameduapi.parentFunc('getHasBlocks',[]);
		console.log(gameduBlocklyhasBlocks);
	};
	
	Acts.prototype.gameduNextBlock = function()
	{
		var result = gameduapi.parentFunc('getExecuteNextBlock',[]);
		if (result != ""){
			try{
				gameduBlocklyMovement = result[0];
				gameduBlocklyCurrUID  = result[1];
			}catch(e){
				gameduBlocklyMovement = "";
				gameduBlocklyCurrUID = 0;
			}
		}
		console.log(gameduBlocklyMovement);
	};
	
	// ... other actions here ...
	
	pluginProto.acts = new Acts();
	
	//////////////////////////////////////
	// Expressions
	function Exps() {};
	
	// the example expression
	Exps.prototype.MyExpression = function (ret)	// 'ret' must always be the first parameter - always return the expression's result through it!
	{
		ret.set_int(1337);				// return our value
		// ret.set_float(0.5);			// for returning floats
		// ret.set_string("Hello");		// for ef_return_string
		// ret.set_any("woo");			// for ef_return_any, accepts either a number or string
	};
	
	Exps.prototype.PlayerID = function (ret)	// 'ret' must always be the first parameter - always return the expression's result through it!
	{
		console.log('expr. '+defaultPlayerData["id"]);
		if (defaultPlayerData["id"])
			ret.set_int(defaultPlayerData["id"]);			// for ef_return_string
		else
			ret.set_int(0);
	};
	
	// the example expression
	Exps.prototype.PlayerName = function (ret)	// 'ret' must always be the first parameter - always return the expression's result through it!
	{
		//ret.set_int(1337);				// return our value
		// ret.set_float(0.5);			// for returning floats
		console.log('expr. '+defaultPlayerData["name"]);
		if (defaultPlayerData["name"])
			ret.set_string(defaultPlayerData["name"]);			// for ef_return_string
		else
			ret.set_string("Desconhecido");
		// ret.set_any("woo");			// for ef_return_any, accepts either a number or string
	};
	
	Exps.prototype.MaxGameTries = function (ret)
	{
		console.log('expr. '+defaultGameData["maxTries"]);
		if (defaultGameData["maxTries"])
			ret.set_int(defaultGameData["maxTries"]);
		else
			ret.set_int(0);
	};
	
	Exps.prototype.HasBlocks = function (ret)
	{
		console.log('expr. '+gameduBlocklyhasBlocks);
		if (gameduBlocklyhasBlocks)
			ret.set_int(gameduBlocklyhasBlocks);
		else
			ret.set_int(0);
	};
	
	Exps.prototype.CurrUID = function (ret)
	{
		console.log('uid. '+gameduBlocklyCurrUID);
		if (gameduBlocklyCurrUID)
			ret.set_int(gameduBlocklyCurrUID);
		else
			ret.set_int(0);
	};
	
	// the example expression
	Exps.prototype.Movement = function (ret)	// 'ret' must always be the first parameter - always return the expression's result through it!
	{
		console.log('Movemento '+ gameduBlocklyMovement);
		if (gameduBlocklyMovement)
			ret.set_string(gameduBlocklyMovement);			// for ef_return_string
		else
			ret.set_string("");
	};
	
	
	
	Exps.prototype.MaxGameTime = function (ret)
	{
		console.log('expr. '+defaultGameData["maxTime"]);
		if (defaultGameData["maxTime"])
			ret.set_int(defaultGameData["maxTime"]);
		else
			ret.set_int(100);
	};
	
	
	// ... other expressions here ...
	
	pluginProto.exps = new Exps();

}());